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