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