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