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