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