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