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