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