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