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