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