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