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