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