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