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