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