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