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