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