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