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