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