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