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