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