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