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