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