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