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