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